// 允许未使用的代码和未使用的变量警告（编译时忽略这些警告）
#![allow(dead_code, unused_variables)]

// 引入标准库中的Future trait和其他相关类型
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use std::time::Duration;
use tokio::time::Sleep;

/// 一个异步延迟 Future，每次等待指定时间后完成。
struct Delay {
    /// 异步延迟定时器
    sleep: Option<Pin<Box<Sleep>>>,
    /// 延迟时长（秒）
    secs: u64,
}

impl Delay {
    /// 创建一个新的 Delay，secs 指定延迟秒数
    pub fn new(secs: u64) -> Self {
        Delay { sleep: None, secs }
    }
}

// 为Delay类型实现Future trait，使其可以异步等待
impl Future for Delay {
    // 设置Future执行完成后返回的类型为静态字符串引用
    type Output = &'static str;

    /// poll 是 Future 的核心方法，检查延迟是否完成
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        let this = self.get_mut();
        // 如果没有定时器，则创建一个新的异步延迟定时器
        if this.sleep.is_none() {
            this.sleep = Some(Box::pin(tokio::time::sleep(Duration::from_secs(this.secs))));
        }
        // 检查延迟是否完成
        let sleep = this.sleep.as_mut().unwrap();
        match sleep.as_mut().poll(cx) {
            Poll::Ready(_) => {
                println!("Delay completed");
                Poll::Ready("done")
            },
            Poll::Pending => Poll::Pending,
        }
    }
}

// 使用tokio的main宏来运行异步main函数
#[tokio::main]
async fn main() {
    // 创建一个 Delay 实例，设置 2 秒后完成
    let delay = Delay::new(2);

    println!("Waiting for delay..."); // 打印等待信息

    // 使用 await 等待 Delay Future 完成，并获取结果
    let result = delay.await;

    // 打印 Future 返回的结果
    println!("Result: {result}");
    // 打印完成信息
    println!("Delay finished");
}

// 引入stream_demo模块（但代码中未展示该模块内容）
mod stream_demo;
